package com.southgis.ibase.sql.utils;

import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.temporal.Temporal;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * 提供各种不同类型间的转换，一般是字符串到指定类型
 * @author dennis
 *
 */
@Slf4j
public final class ConvertUtil
{
	
	/**
	 * 将数组转换为Set集合，不会返回null。
	 * @param <T>
	 * @param array 原数组，如果为空，则返回空的Set
	 * @return
	 */
	public static <T> HashSet<T> toHashSet(T[] array)
	{
		HashSet<T> ret=new HashSet<>();
		if(array!=null && array.length>0) {
			Collections.addAll(ret, array);
		}
		return ret;
	}
	
	/**
	 * 将数组转换为Set集合，并且排除其中的null项，不会返回null。
	 * @param <T>
	 * @param array
	 * @return
	 */
	public static <T> HashSet<T> toHashSetNotNull(T[] array)
	{
		HashSet<T> ret=new HashSet<>();
		if(array!=null && array.length>0) {
			for(T i:array) {
				if(i!=null)
					ret.add(i);
			}
		}
		return ret;
	}
	
	/**
	 * 将字符串数组转换为Set集合，并且排除null或empty的项，不会返回null。
	 * @param array
	 * @return
	 */
	public static HashSet<String> toHashSetNotEmpty(String[] array)
	{
		return toHashSetNotEmpty(array,false);
	}
	
	/**
	 * 将字符串数组转换为Set集合，并且排除null或empty的项，不会返回null。
	 * @param array
	 * @param trim 是否清除前后的空白符
	 * @return
	 */
	public static HashSet<String> toHashSetNotEmpty(String[] array, boolean trim)
	{
		HashSet<String> ret=new HashSet<>();
		if(array!=null && array.length>0) {
			for(String i:array) {
				if(i==null) continue;
				if(trim) i=i.trim();
				
				if(!i.isEmpty()) {
					ret.add(i);
				}
			}
		}
		return ret;
	}
	
	/**
	 * 创建一个Set集合，并添加一个元素，此元素如果为空(null 或 empty)，则不添加。不会返回null。
	 * @param item 要添加的非空元素
	 * @return
	 */
	public static HashSet<String> asHashSet(String item)
	{
		HashSet<String> ret=new HashSet<>();
		if(item!=null && !item.isEmpty())
			ret.add(item);
		return ret;
	}
	
	/**
	 * 创建一个Map集合，并添加一个元素，此元素如果为空(null)，则不添加。不会返回null。
	 * @param <T> Key类型
	 * @param key Key值
	 * @param item Value值
	 * @return
	 */
	public static <T> HashMap<T, Object> asHashMap(T key, Object item)
	{
		HashMap<T, Object> ret=new HashMap<>();
		if(item!=null)
			ret.put(key, item);
		return ret;
	}
	
	/**
	 * 判断Set集合是否为null，如果不为null返回原值，为null返回一个只读的空Set
	 * @param <T>
	 * @param org
	 * @return 总是不为null的Set集合
	 */
	public static <T> Set<T> ofNullableSet(Set<T> org)
	{
		return org==null?Collections.emptySet():org;
	}
	/**
	 * 判断List集合是否为null，如果不为null返回原值，为null返回一个只读的空List
	 * @param <T>
	 * @param org
	 * @return 总是不为null的List集合
	 */
	public static <T> List<T> ofNullableList(List<T> org)
	{
		return org==null?Collections.emptyList():org;
	}
	/**
	 * 判断Map集合是否为null，如果不为null返回原值，为null返回一个只读的空Map
	 * @param <T>
	 * @param org
	 * @return 总是不为null的Map集合
	 */
	public static <K,V> Map<K,V> ofNullableMap(Map<K,V> org)
	{
		return org==null?Collections.emptyMap():org;
	}

	/**
	 * 向一个Value元素为List的Map对象中添加一个List内元素。一般用于集合分组的场合。
	 * 如果Map的Value元素为null时，内部会创建一个ArrayList。<br>
	 * 要求Map、及内部Value的List对象都是可修改类型。
	 * @param <K> Map的Key值类型
	 * @param <V> Map的Value内的元素类型
	 * @param org 要添加元素的对象
	 * @param key 要添加元素的Key值
	 * @param item 要添加的值（List内）
	 */
	public static <K,V> void addMapListItem(Map<K, List<V>> org, K key, V item)
	{
		List<V> lsItem=org.computeIfAbsent(key, t -> new ArrayList<>());
		lsItem.add(item);
	}
	/**
	 * 从集合中移除指定元素（如果集合是只读的，会抛异常），如果比较相同元素有多个时，
	 * 会全部移除（而使用List或set的remove只移除一个）
	 * @param list
	 *          需要移除元素的字符串集合，不能为null
	 * @param target
	 *          需要移除的目标元素
	 */
	public static void removeElement(Iterable<String> list, String target)
	{
		Iterator<String> it = list.iterator();
		while(it.hasNext())
		{
			if (StringUtils.equals(it.next(), target))
			{
				it.remove();
			}
		}
	}
	
	/**
	 * 截取指定分隔符的左边子串，如果分隔符不存在，则整个字符串返回。
	 * 与{@link org.apache.commons.lang3.StringUtils#substringBefore}区别是，substringBefore在原串为null时，会返回null。
	 * @param src 要截取的字符串
	 * @param split 分隔符
	 * @return 总不为null
	 */
	public static String leftSubStr(String src,String split)
	{
		if(StringUtils.isEmpty(src)) return "";
		int ipos=src.indexOf(split);
		if(ipos>=0) return src.substring(0, ipos);
		return src;
	}
	
	/**
	 * 截取指定分隔符的右边子串，如果分隔符不存在，则返回""。
	 * 与{@link org.apache.commons.lang3.StringUtils#substringAfter}区别是，substringAfter在原串为null时，会返回null。
	 * @param src 要截取的字符串
	 * @param split 分隔符
	 * @return 总不为null
	 */
	public static String rightSubStr(String src,String split)
	{
		if(StringUtils.isEmpty(src)) return "";
		int ipos=src.indexOf(split);
		if(ipos<0) return "";
		return src.substring(ipos+1);
	}
	
	/**
	 * 将指定字符串重复多次，生成新字符串返回
	 * @param chr 要重复的字符（或字符串）
	 * @param iCount 重复记数（如果小于等于0，则返回""）
	 * @param split 重复间的分隔符（如果不需要，则可以设为null或""）
	 * @return
	 */
	public static String repeatChar(String chr, int iCount, String split)
	{
		if(iCount<=0) return "";
		if(iCount==1) return chr;
		StringBuilder sb=new StringBuilder();
		if(split==null) split="";
		for(int ix=0;ix<iCount;++ix){
			if(!split.isEmpty())
				sb.append(split);
			sb.append(chr);
		}
		if(!split.isEmpty()){
			sb=sb.delete(0, split.length());
		}
		return sb.toString();
	}

	/**
	 * 将字节数组转换为十六进制表示的字符串(不够两位会补0)。
	 * @param byBuf 要转换的字节数组。
	 * @return 返回十六进制字符串
	 */
	public static String byteToString(byte[] byBuf)
	{
		return byteToString(byBuf,true);
	}
	/**
	 * 将字节数组转换为十六进制表示的字符串。
	 * @param byBuf 要转换的字节数组。
	 * @param bPrefixZero 是否带前缀0（一个字节两个字符，如果小于16时，指出是否补0对齐）。
	 * 如：值为0xA时，当此参数为true，返回"0A"；为false，返回"A"
	 * @return 转换后的字符串，如果出错，返回null
	 */
	public static String byteToString(byte[] byBuf, boolean bPrefixZero)
	{
		if(byBuf==null) return null;
		StringBuilder sb=new StringBuilder();
		String sNum;
		for (int i = 0; i < byBuf.length; i++)
		{
			sNum=Integer.toHexString(byBuf[i]&0xFF);
			if(sNum.length()==1 && bPrefixZero)
				sb.append("0");
			sb.append(sNum);
		}
		return sb.toString();
	}

	/**
	 * 转换为字符串值。
	 * 如果为null，返回sDefault值。
	 * 如果是Date/Calendar/UUID类型，将返回标准格式的字符串；
	 * 如果是byte[]，将返回Base64编码串。
	 * 其他类型，返回toString的值
	 * @param ov
	 * @param sDefault
	 * @return
	 */
	public static String getValue(Object ov, String sDefault)
	{
		if (ov == null)
			return sDefault;
		if (ov instanceof String)
			return (String)ov;
		if (ov instanceof Date)
			return DateUtil.dateToString((Date)ov);
		if(ov instanceof Calendar)
			return DateUtil.dateToString(((Calendar)ov).getTime());
		if (ov instanceof UUID)
			return ((UUID)ov).toString();
		if (ov instanceof byte[])
			return Base64.getEncoder().encodeToString((byte[])ov);
		//添加clob类型的格式装换 tmg 2019-01-18
		if(ov instanceof java.sql.Clob){
			String result = sDefault;
			try{
				java.sql.Clob clob = (java.sql.Clob)ov;
				result = clob.getSubString(1, (int) clob.length());
			}catch(Exception e) {
				log.warn("取字符串值",e);
			}
			return result;
		}

		
		return ov.toString();
	}
	/**
	 * 尝试转换成整数。如果出错，返回指定默认值。
	 * Double/Float值，将截取整数部分；
	 * 
	 * @param ov
	 * @param iDefault
	 * @return
	 */
	public static int getValue(Object ov, int iDefault)
	{
		if (ov == null)
			return iDefault;
		if (ov instanceof Integer)
			return (int)ov;
		if(ov instanceof Short)
			return (short)ov;
		if(ov instanceof Long)
			return (int)(long)ov;//(dennis)可能会溢出
		if(ov instanceof BigInteger)
			return ((BigInteger)ov).intValue();
		if(ov instanceof BigDecimal)
			return ((BigDecimal)ov).intValue();
		if(ov instanceof Double)
			return (int)(double)ov;
		if(ov instanceof Float)
			return (int)(float)ov;
		if(ov instanceof Character)
			return (int)(char)ov;
		if(ov instanceof Byte)
			return (byte)ov;
		if(ov instanceof Boolean)
			return ((boolean)ov)?1:0;
		
		try
		{
			String sVal=getValue(ov, "").replace(",","");
			if (sVal.indexOf(".") >= 0)
			{
				//截断取整（不四舍五入）
				return (int)Double.parseDouble(sVal);
			}
			else
			{
				return StringUtils.isEmpty(sVal)?iDefault:Integer.parseInt(sVal);
			}
		}
		catch(Exception ex)
		{
			log.warn("取整数值", ex);
			return iDefault;
		}
	}
	/**
	 * 尝试转换成长整数。如果出错，返回指定默认值。
	 * Double/Float值，将截取整数部分；
	 * 
	 * @param ov
	 * @param lDefault
	 * @return
	 */
	public static long getValue(Object ov, long lDefault)
	{
		if (ov == null)
			return lDefault;
		if (ov instanceof Integer)
			return (int)ov;
		if(ov instanceof Short)
			return (short)ov;
		if(ov instanceof Long)
			return (long)ov;
		if(ov instanceof BigInteger)
			return ((BigInteger)ov).longValue();
		if(ov instanceof BigDecimal)
			return ((BigDecimal)ov).longValue();
		if(ov instanceof Double)
			return (long)(double)ov;
		if(ov instanceof Float)
			return (long)(float)ov;
		if(ov instanceof Character)
			return (long)(char)ov;
		if(ov instanceof Byte)
			return (byte)ov;
		if(ov instanceof Boolean)
			return ((boolean)ov)?1:0;
		
		try
		{
			String sVal=getValue(ov, "").replace(",","");
			if (sVal.indexOf(".") >= 0)
			{
				//截断取整（不四舍五入）
				return (long)Double.parseDouble(sVal);
			}
			else
			{
				return StringUtils.isEmpty(sVal)?lDefault:Long.parseLong(sVal);
			}
		}
		catch(Exception ex)
		{
			log.warn("取长整数值", ex);
			return lDefault;
		}
	}
	/**
	 * 转换为无限大的整数。注：对于byte[]值，将调用new BigInteger(byte[])
	 * @param ov
	 * @param biDefautl
	 * @return
	 */
	public static BigInteger getValue(Object ov, BigInteger biDefautl)
	{
		if (ov == null)
			return biDefautl;
		if (ov instanceof Integer)
			return BigInteger.valueOf((int)ov);
		if(ov instanceof Short)
			return BigInteger.valueOf((short)ov);
		if(ov instanceof Long)
			return BigInteger.valueOf((long)ov);
		if(ov instanceof BigInteger)
			return (BigInteger)ov;
		if(ov instanceof BigDecimal)
			return ((BigDecimal)ov).toBigInteger();
		if(ov instanceof Double)
			return BigDecimal.valueOf((double)ov).toBigInteger();
		if(ov instanceof Float)
			return BigInteger.valueOf((long)(float)ov);
		if(ov instanceof Byte)
			return BigInteger.valueOf((byte)ov);
		if(ov instanceof Character)
			return BigInteger.valueOf((char)ov);
		if(ov instanceof Boolean)
			return BigInteger.valueOf(((boolean)ov)?1:0);
		if(ov instanceof byte[])
			return new BigInteger((byte[])ov);
		
		try
		{
			String sVal=getValue(ov, "").replace(",","");
			int iPos=sVal.indexOf(".");
			if (iPos >= 0)
			{
				//截断取整（不四舍五入）
				sVal=sVal.substring(0,iPos);
				if(sVal.isEmpty()) sVal="0";
			}
			return new BigInteger(sVal);
		}
		catch(Exception ex)
		{
			log.warn("取大整数值", ex);
			return biDefautl;
		}
	}
	/**
	 * 尝试转换成Double。如果出错，返回指定默认值。
	 * 
	 * @param ov
	 * @param dDefault
	 * @return
	 */
	public static double getValue(Object ov, double dDefault)
	{
		if (ov == null)
			return dDefault;
		if (ov instanceof Integer)
			return (int)ov;
		if(ov instanceof Short)
			return (short)ov;
		if(ov instanceof Long)
			return (long)ov;
		if(ov instanceof BigInteger)
			return ((BigInteger)ov).doubleValue();
		if(ov instanceof BigDecimal)
			return ((BigDecimal)ov).doubleValue();
		if(ov instanceof Double)
			return (double)ov;
		if(ov instanceof Float)
			return (float)ov;
		if(ov instanceof Character)
			return (char)ov;
		if(ov instanceof Byte)
			return (byte)ov;
		if(ov instanceof Boolean)
			return ((boolean)ov)?1.0:0.0;
		
		try
		{
			String sVal=getValue(ov, "");
			return StringUtils.isEmpty(sVal)?dDefault:Double.parseDouble(sVal);
		}
		catch(Exception ex)
		{
			log.warn("取小数值", ex);
			return dDefault;
		}
	}
	
	/**
	 * 尝试转换成无限大的小数。如果出错，返回指定默认值。注：对于byte[]值，将调用new BigDecimal(new BigInteger(byte[]))
	 * 
	 * @param ov
	 * @param bdDefault
	 * @return
	 */
	public static BigDecimal getValue(Object ov, BigDecimal bdDefault)
	{
		if (ov == null)
			return bdDefault;
		if(ov instanceof BigDecimal)
			return (BigDecimal)ov;
		if(ov instanceof Double)
			return BigDecimal.valueOf((double)ov);
		if(ov instanceof Float)
			return BigDecimal.valueOf((float)ov);
		if (ov instanceof Integer)
			return BigDecimal.valueOf((int)ov);
		if(ov instanceof Short)
			return BigDecimal.valueOf((short)ov);
		if(ov instanceof Long)
			return BigDecimal.valueOf((long)ov);
		if(ov instanceof BigInteger)
			return new BigDecimal((BigInteger)ov);
		if(ov instanceof Character)
			return BigDecimal.valueOf((char)ov);
		if(ov instanceof Byte)
			return BigDecimal.valueOf((byte)ov);
		if(ov instanceof Boolean)
			return BigDecimal.valueOf(((boolean)ov)?1.0:0.0);
		if(ov instanceof byte[])
			return new BigDecimal(new BigInteger((byte[])ov));
		
		try
		{
			String sVal=getValue(ov, "");
			return new BigDecimal(sVal);
		}
		catch(Exception ex)
		{
			log.warn("取大小数值", ex);
			return bdDefault;
		}
	}
	/**
	 * 尝试转换成Boolean。如果出错，返回指定默认值。
	 * @param ov
	 * @param bDefault
	 * @return
	 */
	public static boolean getValue(Object ov, boolean bDefault)
	{
		if (ov == null)
			return bDefault;
		if(ov instanceof Boolean)
			return (boolean)ov;
		if (ov instanceof Integer)
			return ((int)ov)!=0;
		if(ov instanceof Short)
			return ((short)ov)!=0;
		if(ov instanceof Long)
			return ((long)ov)!=0;
		if(ov instanceof BigInteger)
			return ((BigInteger)ov).compareTo(BigInteger.ZERO)==0;
		if(ov instanceof BigDecimal)
			return ((BigDecimal)ov).compareTo(BigDecimal.ZERO)==0;
		if(ov instanceof Double)
			return ((double)ov)!=0.0;
		if(ov instanceof Float)
			return ((float)ov)!=0.0;
		if(ov instanceof Character)
			return ((char)ov)!=0;
		if(ov instanceof Byte)
			return ((byte)ov)!=0;

		try
		{
			String sVal=getValue(ov, "");
			if (sVal.isEmpty())return bDefault;
			
			return Boolean.parseBoolean(sVal);
		}
		catch(Exception ex)
		{
			log.warn("取布尔值", ex);
			return bDefault;
		}
	}
	
	/**
	 * 转换成日期值
	 * @param ov 可以是Date类型，Calendar类型，长整型（时间戳，从1970-1-1以来的毫秒，如果是GMT时间，需要加8小时(28800000ms)），
	 * 其它应为 可格式化日期的字符串类型（包括形如：Mon May 22 2017 21:58:42 GMT+0800 国际标准格式）。<br/>
	 * 注：如果是全数字的字符串，内部将会进行简单判断：<br/>
	 * 如果长度4位或6位或8位或14位，且月/日/时/分/秒的值在有效范围内，将视为yyyy或yyyyMM或yyyyMMdd或yyyyMMddHHmmss格式；<br/>
	 * 否则，将视为时间戳（从1970-1-1以来的毫秒）。<br/>
	 * 如：20170101 视为yyyyMMdd格式的串；<br/>
	 * 20171509 因月份值15不是有效值，则视为时间戳。<br/>
	 * 注意：如果传入的值是 java.sql.Time，转换后日期部分默认为1970-1-1，但原值有日期值，转换时也会保留；
	 *  而java.time.LocalTime类型，转换后日期部分固定为：1970-1-1。
	 * @param dtDefault
	 * @return
	 */
	public static Date getValue(Object ov, Date dtDefault)
	{
		if (ov == null)
			return dtDefault;

		if(ov instanceof java.sql.Timestamp) { //一定要在前面判断，因为Timestamp继承于Date
			return new Date(((java.sql.Timestamp)ov).getTime()); //因为用了不同的比较操作，所以需要转为Date类型
		}
		if(ov instanceof Date || ov instanceof java.sql.Date
				|| ov instanceof java.sql.Time) //java.sql.Time的日期默认为1970-1-1
			return (Date)ov;
		if(ov instanceof Calendar)
			return ((Calendar)ov).getTime();
		//LocalDate/LocalDateTime/LocalTime的转换
		if(ov instanceof LocalDate) {
			return Date.from(((LocalDate)ov).atStartOfDay(ZoneId.systemDefault()).toInstant());
		}
		if(ov instanceof LocalDateTime) {
			return Date.from(((LocalDateTime)ov).atZone(ZoneId.systemDefault()).toInstant());
		}
		if(ov instanceof LocalTime) {// 日期为1970-1-1
			return Date.from(((LocalTime)ov).atDate(LocalDate.of(1970, 1, 1)).atZone(ZoneId.systemDefault()).toInstant());
		}
		if(ov instanceof ZonedDateTime) {
			return Date.from(((ZonedDateTime)ov).toInstant());
		}
		//-------------
		if(ov instanceof Long)
			return new Date((long)ov);
		if(ov instanceof BigInteger)
			return new Date(((BigInteger)ov).longValue());
		if(ov instanceof BigDecimal)
			return new Date(((BigDecimal)ov).longValue());
		try{
			Date dt = DateUtil.stringToDate(ov.toString());
			if(dt==null)dt=dtDefault;
			return dt;
		}
		catch(Exception ex)
		{
			log.warn("取日期值", ex);
			return dtDefault;
		}
	}

	/**
	 * 根据类型转换值，仅处理基本类型值、字符串、日期值。转换失败会返回0/false/'\0'/null(String|Date)。<br>
	 * 其他类型，仅起到强制类型转换的效果，如果转换失败，会返回null。<br>
	 * 特别的，对List和Set类型，可以正确互换。
	 * <p>
	 * 需要注意，由String转char时，原字符串会视为ASCII码的数值（比如：getValue("97", char.class)，会返回'a'）。
	 * </p>
	 * @param <T>
	 * @param ov
	 * @param type 转换的目标类型
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getValue(Object ov, Class<T> type)
	{
		if(type.isInstance(ov))
			return (T)ov;
		
		Object ret=null;
		if(type==String.class) {
			ret=getValue(ov, (String)null);
		}else if(type==Integer.class || type==int.class){
			ret=getValue(ov, 0);
		}else if(type==Short.class || type==short.class) {
			ret=(short)getValue(ov, 0);
		}else if(type==Byte.class || type==byte.class) {
			ret=(byte)getValue(ov, 0);
		}else if(type==Character.class || type==char.class) {
			ret=(char)getValue(ov, 0);//转字符型，值视为整数
		}else if(type==Long.class || type==long.class) {
			ret=getValue(ov, 0L);
		}else if(type==Boolean.class || type==boolean.class) {
			ret=getValue(ov, false);
		}else if(type==Double.class || type==double.class) {
			ret=getValue(ov,0.0);
		}else if(type==Float.class || type==float.class) {
			ret=(float)getValue(ov,0.0);
		}else if(type==BigInteger.class) {
			ret=getValue(ov, BigInteger.ZERO);
		}else if(type==BigDecimal.class) {
			ret=getValue(ov,BigDecimal.ZERO);
		}else if(Date.class.isAssignableFrom(type)) {//各种日期的转换
			Date dtVal=getValue(ov, (Date)null);
			ret=dtVal;
			if(dtVal!=null && !type.isInstance(dtVal)) {
				if(java.sql.Date.class.isAssignableFrom(type)) {
					ret=new java.sql.Date(dtVal.getTime());
				}else if(java.sql.Timestamp.class.isAssignableFrom(type)) {
					ret=new java.sql.Timestamp(dtVal.getTime());
				}else if(java.sql.Time.class.isAssignableFrom(type)) {
					ret=new java.sql.Time(dtVal.getTime()); //注意：类型虽然转为了Time，但日期值未做任何处理
				}
			}
		}else if(Temporal.class.isAssignableFrom(type)) {//各种新日期的转换
			Date dtVal=getValue(ov, (Date)null);
			if(dtVal!=null) {
				ret=dtVal.toInstant();
				ZonedDateTime zdt=((Instant)ret).atZone(ZoneId.systemDefault());
				if(LocalDate.class.isAssignableFrom(type)) {
					ret=zdt.toLocalDate();
				}else if(LocalDateTime.class.isAssignableFrom(type)) {
					ret=zdt.toLocalDateTime();
				}else if(LocalTime.class.isAssignableFrom(type)) {
					ret=zdt.toLocalTime();
				}else if(ZonedDateTime.class.isAssignableFrom(type)) {
					ret=zdt;
				}
			}
		}else if(type==Calendar.class) {
			Date dtVal=getValue(ov, (Date)null);
			if(dtVal!=null) {
				Calendar temp=Calendar.getInstance();
				temp.setTime(dtVal);
				ret=temp;
			}
		}else if(Collection.class.isAssignableFrom(type)) {
			if(Set.class.isAssignableFrom(type)) {//to Set
				if(ov instanceof Collection) {
					Set<Object> temp=null;
					if(!type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
						try {
							temp=(Set<Object>)type.newInstance();
							temp.addAll((Collection<Object>)ov);
						}catch(Exception ex) {
							//屏蔽尝试构造Set对象可能的出错
							temp=null;
						}
					}
					if(temp==null)
						temp=new HashSet<>((Collection<Object>)ov);
					ret=temp;
				}
			}else {// if(List.class.isAssignableFrom(type)) //to List
				if(ov instanceof Collection) {
					List<Object> temp=null;
					if(!type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
						try {
							temp=(List<Object>)type.newInstance();
							temp.addAll((Collection<Object>)ov);
						}catch(Exception ex) {
							//屏蔽尝试构造List对象可能的出错
							temp=null;
						}
					}
					if(temp==null)
						temp=new ArrayList<>((Collection<Object>)ov);
					ret=temp;
				}
			}
//	}else {
//		ret=ov;
		}
		return (T)ret;
	}

}